/******************************************************************************
**                                                                           **
**                 Proprietary and Confidential Information                  **
**                                                                           **
**                 Copyright (c) Conexant Systems, Inc. Unpublished                  **
**                                                                           **
** This source code and the algorithms implemented therein constitute        **
** confidential information and may compromise trade secrets of Conexant Systems,    **
** Inc. or its associates, and any unauthorized use thereof is prohibited.   **
**                                                                           **
******************************************************************************/

#ifndef _dc_lipp_api_h_
#define _dc_lipp_api_h_

//#define SDK_LIPP_REVISION  1     // Compatible to SDK 2.1 and prior
#define SDK_LIPP_REVISION  3      // no longer referenced on SDK 2.4.1 or later

/******************************************************************************
*  FILE FORMAT:
*      1. INCLUDES 
*      2. ENUMERATIONS 
*      3. DEFINES
*      4. STRUCTURES
*      5. GLOBALS
*      6. PRIVATE FUNCTION PROTOTYPES
*      7. FUNCTIONS
******************************************************************************/

/******************************************************************************
*  1. INCLUDES
******************************************************************************/
#include "dc_type.h"
#ifndef WIN32
#include "tx_api.h"
#endif
#include "dc_imgbuf_api.h"

/******************************************************************************
*  2. ENUMERATIONS
******************************************************************************/
typedef enum {
  LIPP_BUFFER_PROFILE_LOW=0,
  //LIPP_BUFFER_PROFILE_MEDIUM,
  LIPP_BUFFER_PROFILE_HIGH,
  LIPP_BUFFER_PROFILE_LAST
} LIPP_BUFFER_PROFILE_t;

#define LIPP_PLATE_COLOR_C  0
#define LIPP_PLATE_COLOR_M  1
#define LIPP_PLATE_COLOR_Y  2
#define LIPP_PLATE_COLOR_K  3
#define LIPP_PLATE_COLOR_LAST  4  // invalid color
typedef UINT32 LIPP_PLATE_COLOR_t;

typedef enum LIPP_EVENT_ENUM {
  LIPP_EVENT_JOB_BEGIN=0,
  LIPP_EVENT_JOB_END,
  LIPP_EVENT_PLATESET_BEGIN,
  LIPP_EVENT_PLATESET_END,
  LIPP_EVENT_PLATESET_DELETE,
  LIPP_EVENT_IMAGE_BEGIN,
  LIPP_EVENT_IMAGE_END,
  LIPP_EVENT_IMAGE_CANCEL,
  LIPP_EVENT_PLATE_GET,
  LIPP_EVENT_PLATE_CANCEL,
  LIPP_EVENT_PLATE_DONE,
  LIPP_EVENT_MAX_DMB_LIMIT,
  LIPP_EVENT_MAX_DMB_OK,
  LIPP_EVENT_SYS_DMB_LIMIT,
  LIPP_EVENT_SYS_DMB_OK,
  LIPP_EVENT_IMAGE_PROGRESS_COMPLETE,
  LIPP_EVENT_LAST
} LIPP_EVENT_t;

typedef enum {
  LIPP_AUTO_CONTENT_TYPE_OFF=0,
  LIPP_AUTO_CONTENT_TYPE_ON,
  LIPP_AUTO_CONTENT_TYPE_LAST
} LIPP_AUTO_CONTENT_TYPE_t;


#define LIPP_ROTATE_NONE  0
#define LIPP_ROTATE_90CW  (1<<0)
#define LIPP_ROTATE_90CCW (1<<1)
#define LIPP_ROTATE_VFLIP (1<<2)
typedef UINT32 LIPP_ROTATE_t;

typedef enum {
  LIPP_SCALE_TYPE_NORMAL=0,
  LIPP_SCALE_TYPE_600x600_1200x600,
  LIPP_SCALE_TYPE_600x600_2400x600,
  LIPP_SCALE_TYPE_600x300_600x600,
  LIPP_SCALE_TYPE_LAST
} LIPP_SCALE_TYPE_t;

typedef enum {
  LIPP_HALFTONE_MODE_THRESHOLD=0,
  LIPP_HALFTONE_MODE_ERROR_DIFFUSION,
  LIPP_HALFTONE_MODE_DITHER,
  LIPP_HALFTONE_MODE_LAST
} LIPP_HALFTONE_MODE_t;

typedef enum {
  LIPP_CONTRAST_NORMAL =0,
  LIPP_CONTRAST_DECREASE,
  LIPP_CONTRAST_INCREASE,
  LIPP_CONTRAST_HIGH_DECREASE,
  LIPP_CONTRAST_HIGH_INCREASE,
  LIPP_CONTRAST_HIGHER_INCREASE,
  LIPP_CONTRAST_HIGHEST_INCREASE
} LIPP_CONTRAST_t;

#define LIPP_EDIFFUSION_OP_NONE                 0
#define LIPP_EDIFFUSION_OP_Color_Style          (1 << 0)
#define LIPP_EDIFFUSION_OP_Midtone_1Pass        (1 << 1)
#define LIPP_EDIFFUSION_OP_Filter_Modify        (1 << 2)
#define LIPP_EDIFFUSION_OP_Always_1Pass         (1 << 3)
#define LIPP_EDIFFUSION_OP_Symmetry_Adjust      (1 << 4)
#define LIPP_EDIFFUSION_OP_LevelTransitionNoise (1 << 5)
#define LIPP_EDIFFUSION_OP_LevelMidpointNoise   (1 << 6)

#define LIPP_EDIFFUSION_OP_DEFAULT              LIPP_EDIFFUSION_OP_NONE

typedef UINT32 LIPP_EDIFFUSION_OP_t;

typedef enum {
  LIPP_ADJUST_CONTROL_NONE=0,
  LIPP_ADJUST_CONTROL_ENABLE,
  LIPP_ADJUST_CONTROL_ENABLE_WITH_TOP,
  LIPP_ADJUST_CONTROL_ENABLE_WITH_ALL,
  LIPP_ADJUST_CONTROL_LAST,
} LIPP_ADJUST_CONTROL_t;

/******************************************************************************
*  3. DEFINES
******************************************************************************/

//#define LIPP_EXTENT_IMGBUF_DEFINE  // Extent as a type of DC_IMGBUF instead of DC_CIRCBUF.

#define LIPP_PRIMARY_THREAD_NAME   "lipp_p"
#define LIPP_SECONDARY_THREAD_NAME "lipp_s"

#define LIPP_1UP_ENTRY      1
#define LIPP_2UP_ENTRY      2
#define LIPP_4UP_ENTRY      4

#define LIPP_MAX_NUP_ENTRY  LIPP_4UP_ENTRY

/* ENVET ERROR CODE */
#define LIPP_EVENT_ERROR_NONE                        0x00000000
#define LIPP_EVENT_ERROR_PLATESET_FULL               0x00000001
#define LIPP_EVENT_ERROR_PLATESET_INVALID_HANDLE     0x00000002
#define LIPP_EVENT_ERROR_IMAGE_FULL                  0x00000004
#define LIPP_EVENT_ERROR_PLATE_CREATE                0x00000008
#define LIPP_EVENT_ERROR_PLATE_DONE                  0x00000010
#define LIPP_EVENT_ERROR_PLATESET_ACTIVE             0x00000020
#define LIPP_EVENT_ERROR_PLATE_BUFFER_DELETE         0x00000040
#define LIPP_EVENT_ERROR_UNDEFINED                   0x80000000

#ifndef DC_DMB_UNLIMITED 
#define DC_DMB_UNLIMITED    0
#endif

// Define for full layout support
#define SDK_LIPP_FULL_LAYOUT  1

// # of added scanlines at top and bottom of source input
// those padded data does not have to be white, so any data OK!!!
#define DC_LIPP_DUMMY_SCANLINES_TOPnBOT     8

// Comply with the requirement that the height of source image is 2xDC_LIPP_DUMMY_SCANLINES_TOPnBOT scanlines
// bigger than the actual source data
// ie. DC_LIPP_DUMMY_SCANLINES_TOPnBOT scalines at top and bottome each.
#define DC_LIPP_INPUT_HEIGHT_WITH_TOPnBOT

/******************************************************************************
*  4. STRUCTURES
******************************************************************************/

/******************************************************************************
* Each of 256 classes is mapped to one of the index of hardware units {0, 1}
* class : 0 : unclassified
*         1 : photo
*         2 : black text
*         3-255 : TBD
*******************************************************************************/
typedef struct {
  UINT8 table[256];
} LIPP_CONTENTTYPE_INDEXED_LUT_t;

//typedef struct
//{
//  UINT8 *trc[4];
//} LIPP_TRC_TABLE_t;

typedef UINT32 LIPP_PLATESET_h;
typedef UINT32 LIPP_EVENT_ERROR_t;

typedef struct 
{
  struct {
    UINT8 enable;		// mapping to PO_ShearControl enable bit
    UINT8 direction;		// mapping to PO_ShearControl Direction bit
    UINT8 size;			// mapping to PO_ShearControl Size bit
    UINT32 interval;		// mapping to PO_ShearInterval
    UINT32 offset;		// mapping PO_ShearOffset
  } color[4];

} LIPP_SHEAR_INFO_t;

/******************************************************************************
*  5. GLOBALS
******************************************************************************/

/******************************************************************************
*  6. FUNCTION PROTOTYPES
******************************************************************************/

/** LIPP Threads APIs **/
/*****************************************************************************/
/*  @brief      for client to set up the LIPP threads
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_setup 
 *
 *  @output     none
 *
 *  @param      primary_priority - thread of priority of the LIPP primary thread
 *              for image processing and compression to store input image, {1,31}
 *  @param      secondary_priority - thread of priority of the LIPP primary thread
 *              for decompression and rotation to deliver plates, {1, 31}
 *  @param      ignored - not used
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_setup
(UINT primary_priority, UINT secondary_priority, DC_MEM_PARAMS_t *ignored);

/*****************************************************************************/
/*  @brief      for client to create LIPP threads and initialize LIPP
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_initialize 
 *
 *  @output     none
 *
 *  @param      ignored - not used
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_initialize (DC_MEM_PARAMS_t *ignored);

#ifndef WIN32
/*****************************************************************************/
/*  @brief      for client to get a thread control block
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_thread_get 
 *
 *  @output     none
 *
 *  @param      name - pointer to name of thread
 *  @param      thread - pointer to datum in that the thread control block is returned.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_thread_get (char *name, TX_THREAD **thread);
#endif

/** LIPP Job Related APIs **/
/*****************************************************************************/
/*  @brief      for client to let LIPP to set default values to job parameters.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_begin 
 *
 *  @output     default values to job parameters 
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_begin (void);

/*****************************************************************************/
/*  @brief      for client to set job parameters which are limited to max value of each.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_page_pool_set
 *
 *  @output     linesCompleted and totalCompressedBytes of context passed
 *
 *  @param      n_max_images - the max number of images for a job
 *  @param      n_max_platesets - the max number of plate sets
 *  @param      n_max_dmbs - the max number of allowed dmb pages
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_page_pool_set
(UINT32 n_max_images, UINT32 n_max_platesets, UINT32 n_max_dmbs);

/*****************************************************************************/
/*  @brief      for client to set an event callback function 
 *              whcih is called by LIPP when the request is completed.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_callback_set
 *
 *  @output     none
 *
 *  @param      eventCallback - pointer to a event callback function
 *              that has three arg. passed by LIPP.
     LIPP_EVENT               LIPP_EVENT_ERROR    ARG1       ARG2
  LIPP_EVENT_JOB_BEGIN            error_code       n/a        n/a
  LIPP_EVENT_JOB_END              error_code       n/a        n/a
  LIPP_EVENT_PLATESET_BEGIN       error_code       n/a        n/a
  LIPP_EVENT_PLATESET_END         error_code     h_handle     n/a
  LIPP_EVENT_PLATESET_DELETE      error_code     h_handle     n/a
  LIPP_EVENT_IMAGE_BEGIN          error_code       n/a        n/a
  LIPP_EVENT_IMAGE_END            error_code   h_handle(or 0) n/a
  LIPP_EVENT_IMAGE_CANCEL         error_code       n/a        n/a
  LIPP_EVENT_PLATE_GET            error_code     video ch   p_imgbuf of plate 
  LIPP_EVENT_PLATE_CANCEL         error_code     video ch     n/a
  LIPP_EVENT_PLATE_DONE           error_code     video ch     n/a
  LIPP_EVENT_MAX_DMB_LIMIT        error_code       n/a        n/a
  LIPP_EVENT_MAX_DMB_OK           error_code       n/a        n/a
  LIPP_EVENT_SYS_DMB_LIMIT        error_code       n/a        n/a
  LIPP_EVENT_SYS_DMB_OK           error_code       n/a        n/a
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_callback_set
(void (*eventCallback)(LIPP_EVENT_t event, LIPP_EVENT_ERROR_t error_code, UINT32 arg1, UINT32 arg2));

/*****************************************************************************/
/*  @brief      for client to provide LIPP with the size of input
 *              that would be supported up to for additional infos to LIPP.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_input_info_set
 *
 *  @output     none
 *
 *  @param      max_in_width - max input width in pixel
 *  @param      max_in_height - max input hegiht in line
 *  @param      max_in_comps - max # of input components
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_input_info_set
(UINT32 max_in_width,  UINT32 max_in_height, UINT32 max_in_comps);

/*****************************************************************************/
/*  @brief      for client to provide LIPP with the size of output
 *              that would be supported up to for additional infos to LIPP.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_output_info_set
 *
 *  @output     none
 *
 *  @param      max_out_width - max output width in pixel
 *  @param      max_out_height - max output hegiht in line
 *  @param      max_out_comps - max # of output components
 *  @param      max_out_n_bits -   max # of output bits per channel per pixel
 *  @param      n_video_channels - # of video channels, {1, 4}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_output_info_set
(UINT32 max_out_width, UINT32 max_out_height, UINT32 max_out_comps,
 UINT32 max_out_n_bits, UINT32 n_video_channels);

/*****************************************************************************/
/*  @brief      for client to provide LIPP with infos of special modes required
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_mode_info_set
 *
 *  @output     none
 *
 *  @param      duplex_style - {_NONE, _DEFAULT }
 *  @param      rotate_modes - OR'ed LIPP_ROTATE_{NONE, CW, CCW, VFLIP}
 *  @param      n_up - max # of images on a plate 
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_mode_info_set
(LIPP_ROTATE_t rotate_modes, UINT32 n_up);

/*****************************************************************************/
/*  @brief      for client to select n-up layout limitation of rotation.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_nup_limit_set
 *
 *  @output     
 *
 *  @param      enable  - TRUE if a subset of n-up layout is applied
 *                        in order to reduce requried memory for rotation.
 *                        CW/CCW rotation applicable ONLY for 2-up portrait.
 *                        otherwise, FALSE as default.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_nup_limit_set
(boolean enable);

/*****************************************************************************/
/*  @brief      for client to provide LIPP with buffer profile
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_buffer_profile_set
 *
 *  @output     
 *
 *  @param      buffer_profile - LIPP_BUFFER_PROFILE_{HIGH,LOW}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_buffer_profile_set
(LIPP_BUFFER_PROFILE_t buffer_profile);


/*****************************************************************************/
/*  @brief      for client to complete job parameter configuration.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_setup_end
 *
 *  @output     LIPP computes the required sizes of protected and un-protected memory
 *              and pass the sizes in pMemParams.
 *
 *  @param      pMemParams - a poinetr to DC_MEM_PARAMS_t for LIPP to store in.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_setup_end (DC_MEM_PARAMS_t *pMemParams);

/*****************************************************************************/
/*  @brief      for client to start a job
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_begin
 *
 *  @output     none
 *
 *  @param      pMemParams - a poinetr to DC_MEM_PARAMS_t to pass working 
 *               protected and un-protected memory.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_begin (DC_MEM_PARAMS_t *pMemParams);

/*****************************************************************************/
/*  @brief      for client to close a active job.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_job_end
 *
 *  @output     LIPP release all occupied memory and returns to inital state.
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_job_end (void);


/** LIPP Plateset Related APIs **/
/*****************************************************************************/
/*  @brief      for client to let LIPP to set default values to plate set parameters.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_setup_begin
 *
 *  @output     default values to plate set parameters.
 *
 *  @param      restore_defaults - init plateset params if non-zero, use previous set if 0.
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_setup_begin (UINT32 restore_defaults);

/*****************************************************************************/
/*  @brief      for client to set the size related params of plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_setup_dimension_set
 *
 *  @output     none
 *
 *  @param      n_bits - # of bits
 *  @param      n_plates - # of plates (colors)
 *  @param      width - the width of plate in pixel
 *  @param      height - the height of plate in line
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_setup_dimension_set
(UINT32 n_bits, UINT32 n_plates, UINT32 width, UINT32 height);

/*****************************************************************************/
/*  @brief      for client to set duplex and n_up modes to plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_setup_mode_set
 *
 *  @output     none
 *
 *  @param      duplex_assist - {LIPP_DUPLEX_ASSIST_NONE, 
 *                               LIPP_DUPLEXT_ASSIST_VERTICAL_MIRROR}
 *  @param      rotate_mode, 
 #if !SDK_LIPP_FULL_LAYOUT
 *              1-up : LIPP_ROTATE_NONE or LIPP_ROTATE_VFLIP
 *              2-up : LIPP_ROTATE_CW   or LIPP_ROTATE_CCW
 *              4-up : LIPP_ROTATE_NONE or LIPP_ROTATE_VFLIP
 #else
 *              n-up : LIPP_ROTATE_NONE,LIPP_ROTATE_VFLIP,LIPP_ROTATE_CW,or LIPP_ROTATE_CCW
 #endif
 *
 *  @param      n_up - {1, LIPP_MAX_NUP_ENTRY=4}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_setup_mode_set
(LIPP_ROTATE_t rotate_mode, UINT32 n_up);

/*****************************************************************************/
/*  @brief      for client to set shear compensation factors for each color plate.
 *              Shear compensation will be performed on a image which is dither-halftoned.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_setup_shear_set
 *
 *  @output     none
 *
 *  @param      plate_color - plate color of the plate set
 *  @param      shear_interval - the amount of shear compensation to perform
 *                 on the specified color plate.
 *  @param      polarity - direcion of shear slope being applied to adjust physical seams.
 *                    TRUE for positive rising from left to right
 *                    FALSE for negative rising from left to right
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_setup_shear_set
 (LIPP_PLATE_COLOR_t plate_color, UINT32 shear_interval, boolean polarity);

/*****************************************************************************/
/*  @brief      for client to complete plate set parameter configuration.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_setup_end
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_setup_end (void);

/*****************************************************************************/
/*  @brief      for client to start a plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_begin
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_begin (void);

/*****************************************************************************/
/*  @brief      for client to close a plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_end
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_end (void);

/*****************************************************************************/
/*  @brief      for client to delete a plate set which was completed
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_delete
 *
 *  @output     none
 *
 *  @param      h_plateset - plateset id to delete
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_delete (LIPP_PLATESET_h h_plateset);

/*****************************************************************************/
/*  @brief      for client to get infos of a plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_info_get
 *
 *  @output     none
 *
 *  @param      h_plateset - plateset id
 *  @param      n_plates - 
 *  @param      n_bits - 
 *  @param      width - 
 *  @param      height -
 *  @param      n_images - 
 *  @param      n_up - 
 *  @param      duplex_assist -
 *  @param      reserv -
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_info_get
 (LIPP_PLATESET_h h_plateset,
  UINT32 *n_plates,
  UINT32 *n_bits,
  UINT32 *width,
  UINT32 *height,
  UINT32 *n_images,
  UINT32 *n_up,
  UINT32 *duplex_assist,
  UINT32 *reserv);

/*****************************************************************************/
/*  @brief      for client to get shear infos of a plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_shear_info_get
 *
 *  @output     none
 *
 *  @param      h_plateset - plateset id
 *  @param      shear_info - shear_info data staructure in which plate info's transferred.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_shear_info_get
 (LIPP_PLATESET_h h_plateset,
  LIPP_SHEAR_INFO_t *shear_info);

/*****************************************************************************/
/*  @brief      for client to get dot counts of a plate set
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plateset_dot_counts_get
 *
 *  @output     none
 *
 *  @param      h_plateset - plateset id
 *  @param      p_hi_count_channel0 - pointer to datum in which a high word of channel0 64-bit count returns
 *  @param      p_lo_count_channel0 - pointer to datum in which a low word of channel0 64-bit count returns
 *  @param      p_hi_count_channel1 - 
 *  @param      p_lo_count_channel1 - 
 *  @param      p_hi_count_channel2 - 
 *  @param      p_lo_count_channel2 - 
 *  @param      p_hi_count_channel3 - 
 *  @param      p_lo_count_channel3 - 
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plateset_dot_counts_get
 (LIPP_PLATESET_h h_plateset,
  UINT32 *p_hi_count_channel0,
  UINT32 *p_lo_count_channel0,
  UINT32 *p_hi_count_channel1,
  UINT32 *p_lo_count_channel1,
  UINT32 *p_hi_count_channel2,
  UINT32 *p_lo_count_channel2,
  UINT32 *p_hi_count_channel3,
  UINT32 *p_lo_count_channel3);

/** LIPP Image Related APIs **/
/*****************************************************************************/
/*  @brief      for client to let LIPP to set default values to image parameters.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_begin
 *
 *  @output     default values to image parameters.
 *
 *  @param      init - init image params if non-zero, use previous set if 0.
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_begin (UINT32 restore_defaults);

/*****************************************************************************/
/*  @brief      for client to specify input image source
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_input_data_set
 *
 *  @output     none
 *
 *  @param      rgb - pointer to DC_IMGBUF of input data
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_input_data_set (DC_IMGBUF *rgb);

/*****************************************************************************/
/*  @brief      for client to specify whether input color needs to be inverted 
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_input_color_invert_set
 *
 *  @output     none
 *
 *  @param      invert
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_input_color_invert_set (boolean invert);

/*****************************************************************************/
/*  @brief      for client to specify extent map source
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_extent_data_set
 *
 *  @output     none
 *
 *  @param      extent - pointer to DC_IMGBUF of extent map data
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
#ifdef LIPP_EXTENT_IMGBUF_DEFINE
DC_RETURN_CODE dc_lipp_image_setup_extent_data_set (DC_IMGBUF *extent);
#else
DC_RETURN_CODE dc_lipp_image_setup_extent_data_set (DC_CIRCBUF *extent);
#endif

/*****************************************************************************/
/*  @brief      for client to specify content type source
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_content_type_data_set
 *
 *  @output     none
 *
 *  @param      content_type - pointer to DC_IMGBUF of content_type data
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_content_type_data_set (DC_IMGBUF *content_type);

/*****************************************************************************/
/*  @brief      for client to enable/disable auto content type  detection.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_auto_content_set
 *
 *  @output     none
 *
 *  @param      auto_content_type - {LIPP_AUTO_CONTENT_TYPE_OFF, LIPP_AUTO_CONTENT_TYPE_ON}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_auto_content_set (LIPP_AUTO_CONTENT_TYPE_t auto_content_type);

/*****************************************************************************/
/*  @brief      for client to set pre-rotated output image size
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_output_set
 *
 *  @output     none
 *
 *  @param      scaled_width - width in pixel
 *  @param      scaled_height - height in line
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_output_set
(UINT32 scaled_width, UINT32 scaled_height);

/*****************************************************************************/
/*  @brief      for client to set n_up related parameters
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_nup_set
 *
 *  @output     none
 *
 *  @param      horizontal_offset - horizontal position from top and left corner of the plate set
 *              satisfy the condition of ((horizontal_offset*n_bit)%8=0)
 *  @param      vertical_offset - vertical position
 *  @param      n_up_index - n-up layout index {0, n_up(plateset)-1}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_nup_set
(UINT32 horizontal_offset, UINT32 vertical_offset, UINT32 n_up_index);

/*****************************************************************************/
/*  @brief      for client to set rotation mode
 *
 *  @ingroup    LIPP
 *  @b function dc__lipp_image_setup_rotation_set
 *
 *  @output     none
 *
 *  @param      rotate - {LIPP_ROTATE_NONE, LIPP_ROTATE_90CW, LIPP_ROTATE_90CCW, LIPP_ROTATE_VFLIP}
 *              Given this call, same as rotation on plateset 
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc__lipp_image_setup_rotation_set (LIPP_ROTATE_t rotate);

/*****************************************************************************/
/*  @brief      for client to set scaling mode
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_scale_type_set
 *
 *  @output     none
 *
 *  @param      scale_type - {LIPP_SCALE_TYPE_NORMAL,
 *                            LIPP_SCALE_TYPE_600x600_1200x600,
 *                            LIPP_SCALE_TYPE_600x600_2400x600,
 *                            LIPP_SCALE_TYPE_600x300_600x600}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_scale_type_set (LIPP_SCALE_TYPE_t scale_type);

/*****************************************************************************/
/*  @brief      for client to set level adjustment parameters
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_level1_set
 *
 *  @output     none
 *
 *  @param      contrast - one of enum LIPP_CONTRAST_t
 *  @param      brightness - in range of {-127, 127}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_level1_set 
(LIPP_CONTRAST_t contrast, INT32 brightness);

/*****************************************************************************/
/*  @brief      for client to set level adjustment parameters
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_level2_set
 *
 *  @output     none
 *
 *  @param      white_guard - offset to white level, {0, 127}
 *  @param      black_guard - offset to black level, {0, 127}
 *  @param      white_clip - code region to be clipped to white, 
 *                           no clipping if 0
 *  @param      black_clip - (255- code region) to be clipped to black,
 *                            no clipping if 0
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_level2_set 
(UINT32 white_guard, UINT32 black_guard, UINT32 white_clip, UINT32 black_clip);

/*****************************************************************************/
/*  @brief      for client to set level adjustment parameters
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_level3_set
 *
 *  @output     none
 *
 *  @param      adjust_control
 *  @param      n_top_lines - {0, 255}
 *  @param      white_level - 23-bits:7.16
 *  @param      white_sensitivity - {0, 31}
 *  @param      black_sensitivity - {0, 31}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_level3_set 
(LIPP_ADJUST_CONTROL_t adjust_control, UINT32 n_top_lines, UINT32 white_level, UINT32 white_sensitivity, UINT32 black_sensitivity);

/*****************************************************************************/
/*  @brief      for client to set tonal response curve (TRC) tables
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_trc_table_set
 *
 *  @output     none
 *
 *  @param      table - pointer to arrays of TRC table, *table[4]
 *                      one table consists of 65 entries.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_trc_table_set (UINT8 *trc[4]);

/*****************************************************************************/
/*  @brief      for client to map FIR units to pixel classification
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_fir_content_mapping_set
 *
 *  @output     none
 *
 *  @param      table - pointer to a table mapping FIR units to pixel classification
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_fir_content_mapping_set (LIPP_CONTENTTYPE_INDEXED_LUT_t *table);

/*****************************************************************************/
/*  @brief      for client to set fir
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_fir_set
 *
 *  @output     none
 *
 *  @param      index - index of fir units {0, 1}
 *  @param      width - the width of fir kernel 
 *  @param      height - the height of fir kernel
 *  @param      shift_count - count for result to be left shifted
 *  @param      tap - pointer to tap values from tap notation A (center tap)
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_fir_set
(UINT32 index, UINT32 width, UINT32 height, UINT32 shift_count, UINT8 *tap);

/*****************************************************************************/
/*  @brief      for client to map CSC units to pixel classification
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_csc_content_mapping_set
 *
 *  @output     none
 *
 *  @param      table - pointer to a table mapping CSC units to pixel classification
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_csc_content_mapping_set (LIPP_CONTENTTYPE_INDEXED_LUT_t *table);

/*****************************************************************************/
/*  @brief      for client to set color space conversion (CSC) tables
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_csc_set
 *
 *  @output     none
 *
 *  @param      index - index of color space conversion units {0, 1}
 *  @param      res_name1 - pointer to primary resource name
 *  @param      res_name2 - pointer to secondary resource name
 *                  if not NULL, the secondary csc table is merged to 
 *                  the primary one.
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_csc_set
(UINT32 index, char *res_name1, char *res_name2);

/*****************************************************************************/
/*  @brief      for client to map dither units to pixel classification
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_dither_content_mapping_set
 *
 *  @output     none
 *
 *  @param      table - pointer to a table mapping Dither units to pixel classification
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_dither_content_mapping_set (LIPP_CONTENTTYPE_INDEXED_LUT_t *table);

/*****************************************************************************/
/*  @brief      for client to set dither table
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_dither_set
 *
 *  @output     none
 *
 *  @param      index - index of dither units {0, 1}
 *  @param      color - LIPP_PLATE_COLOR_t
 *  @param      width - the width of dither kernel in pixel, {1, 128}
 *  @param      height - the height of dither kernel in line, {1, 128}
 *  @param      data - pointer to dither raster data from top and left
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_dither_set
(UINT32 index, LIPP_PLATE_COLOR_t color, UINT32 width, UINT32 height, UINT8 *data);

/*****************************************************************************/
/*  @brief      for client to set shaped dither table with DC2350
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_shaped_dither_set
 *
 *  @output     none
 *
 *  @param      index - index of dither units {0, 1}
 *  @param      color - LIPP_PLATE_COLOR_t
 *  @param      width - the width of dither kernel in pixel, {1, 128}
 *  @param      height - the height of dither kernel in line, {1, 128}
 *  @param      data - pointer to dither raster data from top and left
 *  @param      options - option for future use..
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_shaped_dither_set (UINT32 index,
                                               LIPP_PLATE_COLOR_t color,
                                               UINT32 width,
                                               UINT32 height,
                                               UINT8 *data,
                                               UINT32 options);

/*****************************************************************************/
/*  @brief      for client to set halftone mode
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_halftone_mode_set
 *
 *  @output     none
 *
 *  @param      halftone_mode - {LIPP_HALFTONE_MODE_BYPASS,
 *                               LIPP_HALFTONE_MODE_ERROR_DIFFUSION
 *                               LIPP_HALFTONE_MODE_DITHER}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_halftone_mode_set (LIPP_HALFTONE_MODE_t halftone_mode);

/*****************************************************************************/
/*  @brief      for client to set error diffusion mode, specifically of IP two registers.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_ediffusion_op_set
 *
 *  @output     none
 *
 *  @param      modes - OR'ed with below 
                     LIPP_EDIFFUSION_OP_Color_Style
                     LIPP_EDIFFUSION_OP_Midtone_1Pass
                     LIPP_EDIFFUSION_OP_Filter_Modify
                     LIPP_EDIFFUSION_OP_Always_1Pass
                     LIPP_EDIFFUSION_OP_Symmetry_Adjust
                     LIPP_EDIFFUSION_OP_LevelTransitionNoise
                     LIPP_EDIFFUSION_OP_LevelMidpointNoise
 *                     
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_ediffusion_op_set (LIPP_EDIFFUSION_OP_t modes);

/*****************************************************************************/
/*  @brief      for client to set AS mode
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_as_mode_set
 *
 *  @output     none
 *
 *  @param      nnw_depth     = [0,3]
 *  @param      region_bound  = {0,1}
 *  @param      native_color_input = {TRUE, FALSE}
 *  @param      reserved 
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_as_mode_set
 (UINT32 nnw_depth, UINT32 region_bound, boolean native_color_input, UINT32 reserved);

/*****************************************************************************/
/*  @brief      for client to set AS sizes
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_as_sizes_set
 *
 *  @output     none
 *
 *  @param      region_size   = {8,16,32}
 *  @param      surround_size = {8,16,32}
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_as_sizes_set
 (UINT32 region_size, UINT32 surround_size);

/*****************************************************************************/
/*  @brief      for client to set AS pixel thresholds
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_as_pixel_thresholds_set
 *
 *  @output     none
 *
 *  @param      white_threshold = [0, 255]
 *  @param      black_threshold = [0, 255]
 *  @param      gray_threshold  = [0, 255]
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_as_pixel_thresholds_set
 (UINT32 white_threshold, UINT32 black_threshold, UINT32 gray_threshold);

/*****************************************************************************/
/*  @brief      for client to set AS text region classification
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_as_text_region_classification_set
 *
 *  @output     none
 *
 *  @param      min_black = [0, 0x7fff]
 *  @param      min_white = [0, 0x7fff]
 *  @param      max_color = [0, 0x7fff]
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_as_text_region_classification_set
 (UINT32 min_black, UINT32 min_white, UINT32 max_color);

/*****************************************************************************/
/*  @brief      for client to set AS color region classification
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_as_color_region_classification_set
 *
 *  @output     none
 *
 *  @param      min_color = [0, 0x7fff]
 *  @param      max_black = [0, 0x7fff]
 *  @param      max_white = [0, 0x7fff]
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_as_color_region_classification_set
 (UINT32 min_color, UINT32 max_black, UINT32 max_white);

/*****************************************************************************/
/*  @brief      for client to enable/disable FLT block.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_flt_set
 *
 *  @output     none
 *
 *  @param      enable - TRUE or FALSE
 *
 *  @return     DC_SUCCESS, DC_INVALID_EXECUTION_ORDER, DC_API_NOT_SUPPORT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_flt_set(boolean enable);

/*****************************************************************************/
/*  @brief      for client to complete image parameter configuration.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_setup_end
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_setup_end (void);

/*****************************************************************************/
/*  @brief      for client to start a image processing
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_begin
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_begin (void);

/*****************************************************************************/
/*  @brief      for client to close the opened image
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_end
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_end (void);

/*****************************************************************************/
/*  @brief      for client to abort current image processing for the opened image
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_image_cancel
 *
 *  @output     none
 *
 *  @param      none
 *
 *  @return     DC_SUCCESS, DC_FAILURE
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_image_cancel (void);

/** LIPP Deliver of Plate Related API **/

/*****************************************************************************/
/*  @brief      for client to get a plate output data from LIPP
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plate_get
 *
 *  @output     none
 *
 *  @param      h_plateset - plateset id to process
 *  @param      plate_color - plate color of the plate set
 *  @param      video_channel - the video channel no.to transfer
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plate_get
(LIPP_PLATESET_h h_plateset, LIPP_PLATE_COLOR_t plate_color, UINT32 video_channel);

/*****************************************************************************/
/*  @brief      for client to cancel a delivery request that is being performed
 *              via the specifed channel
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plate_cancel
 *
 *  @output     none
 *
 *  @param      video_channel - the video channel no.to cancel
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plate_cancel (UINT32 video_channel);

/*****************************************************************************/
/*  @brief      for client to notify LIPP that all plate data was transferred.
 *
 *  @ingroup    LIPP
 *  @b function dc_lipp_plate_done
 *
 *  @output     none
 *
 *  @param      video_channel - the video channel no
 *
 *  @return     DC_SUCCESS, DC_FAILURE, DC_BAD_ARGUMENT
 *
 *****************************************************************************/
DC_RETURN_CODE dc_lipp_plate_done (UINT32 video_channel);

#endif
